home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / os2 / pvm34b3.zip / pvm34b3 / pvm3 / console / cmds.c < prev    next >
C/C++ Source or Header  |  1997-07-22  |  32KB  |  1,601 lines
  1.  
  2. static char rcsid[] =
  3.     "$Id: cmds.c,v 1.20 1997/07/09 13:21:03 pvmsrc Exp $";
  4.  
  5. /*
  6.  *         PVM version 3.4:  Parallel Virtual Machine System
  7.  *               University of Tennessee, Knoxville TN.
  8.  *           Oak Ridge National Laboratory, Oak Ridge TN.
  9.  *                   Emory University, Atlanta GA.
  10.  *      Authors:  J. J. Dongarra, G. E. Fagg, M. Fischer
  11.  *          G. A. Geist, J. A. Kohl, R. J. Manchek, P. Mucci,
  12.  *         P. M. Papadopoulos, S. L. Scott, and V. S. Sunderam
  13.  *                   (C) 1997 All Rights Reserved
  14.  *
  15.  *                              NOTICE
  16.  *
  17.  * Permission to use, copy, modify, and distribute this software and
  18.  * its documentation for any purpose and without fee is hereby granted
  19.  * provided that the above copyright notice appear in all copies and
  20.  * that both the copyright notice and this permission notice appear in
  21.  * supporting documentation.
  22.  *
  23.  * Neither the Institutions (Emory University, Oak Ridge National
  24.  * Laboratory, and University of Tennessee) nor the Authors make any
  25.  * representations about the suitability of this software for any
  26.  * purpose.  This software is provided ``as is'' without express or
  27.  * implied warranty.
  28.  *
  29.  * PVM version 3 was funded in part by the U.S. Department of Energy,
  30.  * the National Science Foundation and the State of Tennessee.
  31.  */
  32.  
  33. /*
  34.  *    cmds.c
  35.  *
  36.  *    PVM console commands.
  37.  *
  38. $Log: cmds.c,v $
  39.  * Revision 1.20  1997/07/09  13:21:03  pvmsrc
  40.  * Fixed Author Header.
  41.  *
  42.  * Revision 1.19  1997/05/13  14:37:38  pvmsrc
  43.  * Changed header file $includes:
  44.  *     - ../src/listmac.h -> listmac.h
  45.  *     - ../src/bfunc.h -> bfunc.h
  46.  *     - use -I$(PVMDIR)/src in Makefile.aimk instead.
  47.  *
  48.  * Revision 1.18  1997/05/02  20:18:51  pvmsrc
  49.  * D-Oh.
  50.  *
  51.  * Revision 1.17  1997/05/01  15:41:14  pvmsrc
  52.  * SGI Compiler Warning Cleanup.
  53.  *
  54.  * Revision 1.16  1997/04/30  21:15:35  pvmsrc
  55.  * SGI Compiler Warning Cleanup.
  56.  *
  57.  * Revision 1.15  1997/04/17  12:53:15  pvmsrc
  58.  * rename of pvm_mboxinfo() to include word "get"
  59.  *
  60.  * Revision 1.14  1997/04/10  20:34:35  pvmsrc
  61.  * "CVS": Modified Files:
  62.  * Typo...
  63.  *
  64.  * Revision 1.13  1997/04/10  20:09:33  pvmsrc
  65.  * Rewrote names_cmd() for new pvm_mboxinfo() syntax.
  66.  *     - pvm_getnames() is history.
  67.  *
  68.  * Revision 1.12  1997/04/09  20:18:13  pvmsrc
  69.  * Minor fixes (like being able to actually pass args to "reset"... :-).
  70.  *
  71.  * Revision 1.11  1997/04/09  19:53:12  pvmsrc
  72.  * Merged resetinfo_cmd() command into reset_cmd() routine.
  73.  *     - check for args, adjust calling parms to pvmreset()...
  74.  *
  75.  * Revision 1.10  1997/04/09  18:31:58  pvmsrc
  76.  * Added new "resetinfo" command.
  77.  *     - like a reset, but without all the task bloodshed...  :-)~
  78.  *
  79.  * Revision 1.9  1997/04/08  17:08:46  pvmsrc
  80.  * Extracted guts of reset_cmd() routine:
  81.  *     - created new system pvmreset() routine for general usage.
  82.  *
  83.  * Revision 1.8  1997/04/01  19:35:44  pvmsrc
  84.  * Corrected flag to PvmMbox...
  85.  *
  86.  * Revision 1.7  1997/04/01  17:04:45  pvmsrc
  87.  * Updated mbox stuff:
  88.  *     - changed args of pvm_putinfo().
  89.  *     - renamed pvm_getinfo() (again) -> pvm_recvinfo(), w/ new syntax.
  90.  *
  91.  * Revision 1.6  1997/03/27  20:09:51  pvmsrc
  92.  * Added PvmNoSpawnParent to pvm_spawn() calls in spawn_cmd().
  93.  *
  94.  * Revision 1.5  1997/02/17  16:29:04  pvmsrc
  95.  * Added checking of pvm_getnoresets() list in reset_cmd().
  96.  *
  97.  * Revision 1.4  1997/01/28  19:13:17  pvmsrc
  98.  * New Copyright Notice & Authors.
  99.  *
  100.  * Revision 1.3  1996/10/24  23:03:39  pvmsrc
  101.  * Updated to new tracing facilty.
  102.  *     - new trace_cmd() options:
  103.  *         * "xpvm" mask mimick.
  104.  *         * "buf" trace buffer size query & set.
  105.  *         * "opt" trace options query & set.
  106.  *     - new job creation handling for spawn command,
  107.  *         tracing vs. output vs. both...
  108.  *     - installed new trc_print_tmask() library call for trace mask dump.
  109.  *
  110.  * Revision 1.2  1996/10/08  18:29:39  pvmsrc
  111.  * Renamed routines:
  112.  *     - pvm_put() -> pvm_putinfo().
  113.  *     - pvm_get() -> pvm_getinfo().
  114.  *
  115.  * Revision 1.1  1996/09/23  20:25:35  pvmsrc
  116.  * Initial revision
  117.  *
  118.  * Revision 1.8  1995/11/02  15:11:40  manchek
  119.  * added to tickle help
  120.  *
  121.  * Revision 1.7  1995/09/05  19:06:52  manchek
  122.  * help text lowercase
  123.  *
  124.  * Revision 1.6  1995/07/03  18:59:51  manchek
  125.  * help text
  126.  *
  127.  * Revision 1.5  1995/07/03  18:57:29  manchek
  128.  * added ps 's' flag, tickle help 100.
  129.  * ps doesn't print tasks with tid 0 unless -x flag used
  130.  *
  131.  * Revision 1.4  1995/05/17  15:26:17  manchek
  132.  * added "return 0" to lots of commands.
  133.  * added idump command
  134.  *
  135.  * Revision 1.3  1994/10/15  18:38:56  manchek
  136.  * updated task flags and ps list headers
  137.  *
  138.  * Revision 1.2  1994/06/03  20:01:51  manchek
  139.  * version 3.3.0
  140.  *
  141.  * Revision 1.1  1993/08/30  23:30:32  manchek
  142.  * Initial revision
  143.  *
  144.  */
  145.  
  146. #include <stdio.h>
  147. #include <fcntl.h>
  148. #ifdef    SYSVSTR
  149. #include <string.h>
  150. #else
  151. #include <strings.h>
  152. #endif
  153. #include <ctype.h>
  154. #include <signal.h>
  155. #include <pvm3.h>
  156. #include <pvmtev.h>
  157. #include "cmd.h"
  158. #include "myalloc.h"
  159. #include "listmac.h"
  160. #include "bfunc.h"
  161. #include "job.h"
  162.  
  163. #define    PVMERRMSG(n)    ((n) <= 0 && (n) > -pvm_nerr \
  164.                         ? pvm_errlist[-(n)] : "Unknown Error")
  165.  
  166. char *getenv();
  167. void i_dump();
  168.  
  169. extern char **environ;
  170.  
  171. extern char *pvm_errlist[];
  172. extern int pvm_nerr;
  173.  
  174. extern struct Pvmtevinfo pvmtevinfo[];
  175.  
  176. int add_cmd();
  177. int alias_cmd();
  178. int conf_cmd();
  179. int delete_cmd();
  180. int echo_cmd();
  181. int export_cmd();
  182. int halt_cmd();
  183. int help_cmd();
  184. int id_cmd();
  185. int idump_cmd();
  186. /*
  187. int insert_cmd();
  188. */
  189. int jobs_cmd();
  190. int kill_cmd();
  191. /*
  192. int lookup_cmd();
  193. */
  194. int mstat_cmd();
  195. int names_cmd();
  196. int quit_cmd();
  197. int pstat_cmd();
  198. int put_cmd();
  199. /*
  200. int remove_cmd();
  201. */
  202. int reset_cmd();
  203. int setenv_cmd();
  204. int sig_cmd();
  205. int spawn_cmd();
  206. int start_cmd();
  207. int tasks_cmd();
  208. int tickle_cmd();
  209. int trace_cmd();
  210. int unalias_cmd();
  211. int unexport_cmd();
  212. int version_cmd();
  213.  
  214. extern struct alias *aliases;            /* from cons.c */
  215. extern struct pvmhostinfo *hostlist;    /* from cons.c */
  216. extern struct job *joblist;                /* from job.c */
  217. extern int mytid;                        /* from cons.c */
  218. extern int narchs;                        /* from cons.c */
  219. extern int nextjob;                        /* from cons.c */
  220. extern int nhosts;                        /* from cons.c */
  221.  
  222.  
  223. struct cmdsw commands[] = {
  224.     { "add",     2, 0, add_cmd },
  225.     { "alias",   1, 0, alias_cmd },
  226.     { "conf",    1, 1, conf_cmd },
  227.     { "delete",  2, 0, delete_cmd },
  228.     { "echo",    1, 0, echo_cmd },
  229.     { "export",    1, 0, export_cmd },
  230.     { "halt",    1, 1, halt_cmd },
  231.     { "help",    1, 2, help_cmd },
  232.     { "id",      1, 1, id_cmd },
  233.     { "idump",   1, 2, idump_cmd },
  234. /*
  235.     { "insert",  4, 4, insert_cmd },
  236. */
  237.     { "jobs",    1, 2, jobs_cmd },
  238.     { "kill",    2, 0, kill_cmd },
  239. /*
  240.     { "lookup",  3, 3, lookup_cmd },
  241. */
  242.     { "mstat",   2, 0, mstat_cmd },
  243.     { "names",   1, 2, names_cmd },
  244.     { "ps",      1, 2, tasks_cmd },
  245.     { "pstat",   2, 0, pstat_cmd },
  246.     { "put",     4, 4, put_cmd },
  247.     { "quit",    1, 1, quit_cmd },
  248. /*
  249.     { "remove",  3, 3, remove_cmd },
  250. */
  251.     { "reset",   1, 4, reset_cmd },
  252.     { "setenv",  1, 0, setenv_cmd },
  253.     { "sig",     3, 0, sig_cmd },
  254.     { "spawn",   2, 0, spawn_cmd },
  255.     { "trace",   1, 0, trace_cmd },
  256.     { "tickle",  2, 11, tickle_cmd },
  257.     { "unalias", 2, 0, unalias_cmd },
  258.     { "unexport", 1, 0, unexport_cmd },
  259.     { "version", 1, 1, version_cmd },
  260.     { 0, 0, 0, 0 }
  261. };
  262.  
  263.  
  264. freealias(ap)
  265.     struct alias *ap;
  266. {
  267.     LISTDELETE(ap, a_link, a_rlink);
  268.     MY_FREE(ap->a_name);
  269.     while (ap->a_num-- > 0)
  270.         MY_FREE(ap->a_args[ap->a_num]);
  271.     MY_FREE(ap->a_args);
  272.     MY_FREE(ap);
  273.     return 0;
  274. }
  275.  
  276.  
  277. struct alias *
  278. newalias(name, num, args)
  279.     char *name;
  280.     int num;
  281.     char **args;
  282. {
  283.     struct alias *ap, *ap2;
  284.  
  285.     ap = TALLOC(1, struct alias, "alias");
  286.     ap->a_name = STRALLOC(name);
  287.     ap->a_args = TALLOC(num + 1, char *, "aargs");
  288.     ap->a_num = num;
  289.     while (num-- > 0)
  290.         ap->a_args[num] = STRALLOC(args[num]);
  291.     for (ap2 = aliases->a_link; ap2 != aliases; ap2 = ap2->a_link)
  292.         if (strcmp(ap2->a_name, name) > 0)
  293.             break;
  294.     LISTPUTBEFORE(ap2, ap, a_link, a_rlink);
  295.     return ap;
  296. }
  297.  
  298.  
  299. struct alias *
  300. findalias(name)
  301.     char *name;
  302. {
  303.     struct alias *ap;
  304.  
  305.     for (ap = aliases->a_link; ap != aliases; ap = ap->a_link)
  306.         if (!strcmp(ap->a_name, name))
  307.             return ap;
  308.     return (struct alias*)0;
  309. }
  310.  
  311.  
  312. docmd(cmd)
  313.     char *cmd;
  314. {
  315.     char *p;
  316.     struct cmdsw *csp;
  317.     struct alias *ap;
  318.     int i;
  319.     int ac;
  320.     char *av[128];
  321.     int self;
  322.  
  323.     /*
  324.     * parse command
  325.     */
  326.  
  327.     ac = sizeof(av)/sizeof(av[0]) - 1;
  328.     if (acav(cmd, &ac, av)) {
  329.         fputs("command too long\n", stdout);
  330.         return 0;
  331.     }
  332.     if (!ac)
  333.         return 0;
  334.  
  335.     /*
  336.     * resolve aliases
  337.     */
  338.  
  339.     for (ap = aliases->a_link; ap != aliases; ap = ap->a_link)
  340.         ap->a_flag = 0;
  341.  
  342.     while (ap = findalias(av[0])) {
  343.         if (ap->a_flag) {
  344.             printf("alias loop\n");
  345.             return 0;
  346.         }
  347.         ap->a_flag = 1;
  348.         if (ap->a_num > 1) {
  349.             if (ac + ap->a_num > sizeof(av)/sizeof(av[0])) {
  350.                 fputs("command too long\n", stdout);
  351.                 return 0;
  352.             }
  353.             for (i = ac; --i > 0; )
  354.                 av[i + ap->a_num - 1] = av[i];
  355.             ac += ap->a_num - 1;
  356.         }
  357.         self = !strcmp(av[0], ap->a_args[0]);
  358.         for (i = ap->a_num; i-- > 0; )
  359.             av[i] = ap->a_args[i];
  360.         if (self)
  361.             break;
  362.     }
  363.  
  364.     /*
  365.     * find command and call it
  366.     */
  367.  
  368.     av[ac] = 0;
  369.     p = av[0];
  370.     for (csp = commands; csp->cmd; csp++) {
  371.         if (!strcmp(csp->cmd, p)) {
  372.             if (ac >= csp->a1 && (ac <= csp->a2 || !csp->a2))
  373.                 (csp->fun)(ac, av);
  374.             else
  375.                 printf("%s: wrong #args\n", p);
  376.             break;
  377.         }
  378.     }
  379.     if (!csp->cmd)
  380.         printf("%s: not found\n", p);
  381.     return 0;
  382. }
  383.  
  384.  
  385. /****************
  386.  **  Commands  **
  387.  **            **
  388.  ****************/
  389.  
  390. add_cmd(ac, av)
  391.     int ac;
  392.     char **av;
  393. {
  394.     int cc;
  395.     int *sv;
  396.     int i;
  397.  
  398.     av++;
  399.     ac--;
  400.     sv = TALLOC(ac, int, "int");
  401.     if ((cc = pvm_addhosts(av, ac, sv)) >= 0) {
  402.         if (cc > 0)
  403.             pvm_recv(-1, 0);    /* waste the notify message */
  404.  
  405.         printf("%d successful\n", cc);
  406.         fputs("                    HOST     DTID\n", stdout);
  407.         for (i = 0; i < ac; i++)
  408.             if ((cc = sv[i]) < 0)
  409.                 printf("%24s %8s\n", av[i], PVMERRMSG(cc));
  410.             else
  411.                 printf("%24s %8x\n", av[i], cc);
  412.     }
  413.     MY_FREE(sv);
  414.     pvm_config(&nhosts, &narchs, &hostlist);
  415.     return 0;
  416. }
  417.  
  418.  
  419. alias_cmd(ac, av)
  420.     int ac;
  421.     char **av;
  422. {
  423.     struct alias *ap;
  424.     char *p;
  425.     int i;
  426.  
  427.     if (ac < 3) {
  428.         for (ap = aliases->a_link; ap != aliases; ap = ap->a_link) {
  429.             fputs(ap->a_name, stdout);
  430.             p = "\t";
  431.             for (i = 0; i < ap->a_num; i++) {
  432.                 printf("%s%s", p, ap->a_args[i]);
  433.                 p = " ";
  434.             }
  435.             fputs("\n", stdout);
  436.         }
  437.  
  438.     } else {
  439.         if (ap = findalias(av[1]))
  440.             freealias(ap);
  441.         newalias(av[1], ac - 2, av + 2);
  442.     }
  443.     return 0;
  444. }
  445.  
  446.  
  447. conf_cmd(ac, av)
  448.     int ac;
  449.     char **av;
  450. {
  451.     int i;
  452.  
  453.     ac = ac;
  454.     av = av;
  455.     if (!pvm_config(&nhosts, &narchs, &hostlist)) {
  456.         printf("%d host%s, %d data format%s\n",
  457.             nhosts, (nhosts > 1 ? "s" : ""), narchs, (narchs > 1 ? "s" : ""));
  458.         fputs("                    HOST     DTID     ARCH   SPEED       DSIG\n", stdout);
  459.         for (i = 0; i < nhosts; i++)
  460.             printf("%24s %8x %8s%8d 0x%08x\n",
  461.                     hostlist[i].hi_name,
  462.                     hostlist[i].hi_tid,
  463.                     hostlist[i].hi_arch,
  464.                     hostlist[i].hi_speed,
  465.                     hostlist[i].hi_dsig);
  466.     }
  467.     return 0;
  468. }
  469.  
  470.  
  471. delete_cmd(ac, av)
  472.     int ac;
  473.     char **av;
  474. {
  475.     int cc;
  476.     int i;
  477.     int *sv;
  478.  
  479.     av++;
  480.     ac--;
  481.     sv = TALLOC(ac, int, "int");
  482.     if ((cc = pvm_delhosts(av, ac, sv)) >= 0) {
  483.         printf("%d successful\n", cc);
  484.         fputs("                    HOST  STATUS\n", stdout);
  485.         for (i = 0; i < ac; i++) {
  486.             printf("%24s  ", av[i]);
  487.             if ((cc = sv[i]) < 0)
  488.                 printf("%8s\n", PVMERRMSG(cc));
  489.             else
  490.                 printf("deleted\n");
  491.         }
  492.     }
  493.     MY_FREE(sv);
  494.     return 0;
  495. }
  496.  
  497.  
  498. echo_cmd(ac, av)
  499.     int ac;
  500.     char **av;
  501. {
  502.     int i;
  503.     char *p = "";
  504.  
  505.     for (i = 1; i < ac; i++) {
  506.         printf("%s%s", p, av[i]);
  507.         p = " ";
  508.     }
  509.     printf("\n");
  510.     return 0;
  511. }
  512.  
  513.  
  514. halt_cmd(ac, av)
  515.     int ac;
  516.     char **av;
  517. {
  518.     ac = ac;
  519.     av = av;
  520.     if (!pvm_halt()) {
  521.         pvmendtask();
  522.         exit(0);
  523.     }
  524.     return 0;
  525. }
  526.  
  527.  
  528. static char *helptx[] = {
  529.  
  530.     "add add         Add hosts to virtual machine",
  531.     "add Syntax:  add hostname ...",
  532.  
  533.     "alias alias       Define/list command aliases",
  534.     "alias Syntax:  alias [name command args ...]",
  535.  
  536.     "conf conf        List virtual machine configuration",
  537.     "conf Syntax:  conf",
  538.     "conf Output fields:",
  539.     "conf   HOST    host name",
  540.     "conf   DTID    tid base of pvmd",
  541.     "conf   ARCH    xhost architecture",
  542.     "conf   SPEED   host relative speed",
  543.  
  544.     "delete delete      Delete hosts from virtual machine",
  545.     "delete Syntax:  delete hostname ...",
  546.  
  547.     "echo echo        Echo arguments",
  548.     "echo Syntax:  echo [ arg ... ]",
  549.  
  550.     "export export      Add environment variables to spawn export list",
  551.     "export Syntax:  export [ varname ... ]",
  552.  
  553.     "halt halt        Stop pvmds",
  554.     "halt Syntax:  halt",
  555.  
  556.     "help help        Print helpful information about a command",
  557.     "help Syntax:  help [ command ]",
  558.  
  559.     "id id          Print console task id",
  560.     "id Syntax:  id",
  561.  
  562.     "idump-idump          Call i_dump to display heap contents",
  563.     "idump-Syntax:  idump [ how ]",
  564.  
  565. /*
  566.     "insert-insert      Add entry to database",
  567.     "insert-Syntax:  insert name index|-1 hexvalue",
  568. */
  569.  
  570.     "jobs jobs        Display list of running jobs",
  571.     "jobs Syntax:  jobs [ options ]",
  572.     "jobs Options:  -l   give long listing",
  573.  
  574.     "kill kill        Terminate tasks",
  575.     "kill Syntax:  kill [ options ] tid ...",
  576.     "kill Options:  -c   kill children of tid",
  577.  
  578. /*
  579.     "lookup-lookup      Find entry in database",
  580.     "lookup-Syntax:  lookup name index|-1",
  581. */
  582.  
  583.     "names names       List message mailbox names",
  584.     "names Syntax:  names [ pattern ]",
  585.  
  586.     "mstat mstat       Show status of hosts",
  587.     "mstat Syntax:  mstat name ...",
  588.  
  589.     "ps ps          List tasks",
  590.     "ps Syntax:  ps [ -axh ]",
  591.     "ps Options:  -a       all hosts (default is local)",
  592.     "ps           -hhost   specific host tid",
  593.     "ps           -nhost   specific host name",
  594.     "ps           -l       long (show process id)",
  595.     "ps           -x       show all tasks (e.g. console and nulls)",
  596.     "ps Output fields:",
  597.     "ps   HOST    host name",
  598.     "ps   TID     task id",
  599.     "ps   PTID    parent task id",
  600.     "ps   PID     task process id",
  601.     "ps   FLAG    status",
  602.     "ps   COMMAND executable name",
  603.     "ps FLAG values:",
  604.     "ps   f   task process is child of pvmd",
  605.     "ps   c   task connected to pvmd",
  606.     "ps   a   task waiting authorization",
  607.     "ps   o   task connection being closed",
  608.     "ps   s   task needs too many shared pages, is deadlocked",
  609.     "ps   H   hoster task",
  610.     "ps   R   resource manager task",
  611.     "ps   T   tasker task",
  612.  
  613.     "pstat pstat       Show status of tasks",
  614.     "pstat Syntax:  pstat tid ...",
  615.  
  616.     "put put         Add entry to message mailbox",
  617.     "put Syntax:  put name flags",
  618.  
  619.     "quit quit        Exit console",
  620.     "quit Syntax:  quit",
  621.  
  622. /*
  623.     "remove-remove      Delete entry from database",
  624.     "remove-Syntax:  remove name index",
  625. */
  626.  
  627.     "reset reset       Kill all tasks, delete leftover mboxes",
  628.     "reset Syntax:  reset\n",
  629.     "reset reset info    Delete orphaned persistent mbox entries",
  630.     "reset Syntax:  reset info [ class [ index ] ]",
  631.  
  632.     "setenv setenv      Display or set environment variables",
  633.     "setenv Syntax:  setenv [ name [ value ] ]",
  634.  
  635.     "sig sig         Send signal to task",
  636.     "sig Syntax:  sig signum task ...",
  637.  
  638.     "spawn spawn       Spawn task",
  639.     "spawn Syntax:  spawn [ options ] file [ arg ... ]",
  640.     "spawn Options:  -(count)  number of tasks, default is 1",
  641.     "spawn           -(host)   spawn on host, default is any",
  642.     "spawn           -(ARCH)   spawn on hosts of ARCH",
  643.     "spawn           -?        enable debugging",
  644.     "spawn           ->        redirect output of job to console",
  645.     "spawn           ->(file)  redirect output of job to file",
  646.     "spawn           ->>(file) append output of job to file",
  647.     "spawn           -@        trace job, display output on console",
  648.     "spawn           -@(file)  trace job, output to file",
  649.  
  650.     "tickle-tickle      Tickle pvmd",
  651.     "tickle-Syntax:  tickle how [ arg ... ]",
  652.     "tickle-How:",
  653.     "tickle-  0   dump heap",
  654.     "tickle-  1   dump host table",
  655.     "tickle-  2   dump local task table",
  656.     "tickle-  3   dump waitc list",
  657.     "tickle-  4   dump message mailbox",
  658.     "tickle-  5   get debugmask",
  659.     "tickle-  6   (mask) set debugmask",
  660.     "tickle-        mask is the sum of the following bits for information about",
  661.     "tickle-           1  Packet routing",
  662.     "tickle-           2  Message routing and entry points",
  663.     "tickle-           4  Task state",
  664.     "tickle-           8  Slave pvmd startup",
  665.     "tickle-          16  Host table updates",
  666.     "tickle-          32  Select loop",
  667.     "tickle-          64  IP network",
  668.     "tickle-         128  Multiprocessor nodes",
  669.     "tickle-         256  Resource manager interface",
  670.     "tickle-         512  Application warnings (scrapped messages etc.)",
  671.     "tickle-        1024  Wait contexts",
  672.     "tickle-        2048  Shared memory operations",
  673.     "tickle-        4096  Semaphores",
  674.     "tickle-        8192  Locks",
  675.     "tickle-  7   (num) set nopax",
  676.     "tickle-  8   (dtid) trigger hostfail",
  677.     "tickle-  9   (rst) dump pvmd statistics, clear if rst true",
  678.     "tickle-  100 dump shared memory data structures",
  679.  
  680.     "trace trace       Set/display trace event mask",
  681.     "trace Syntax:  trace",
  682.     "trace          trace [+] name ...",
  683.     "trace          trace - name ...",
  684.     "trace          trace [+] *",
  685.     "trace          trace - *",
  686.     "trace          trace xpvm (default mask for XPVM display)",
  687.     "trace          trace buf nbytes",
  688.     "trace          trace buf",
  689.     "trace          trace opt < full | time | count >",
  690.     "trace          trace opt",
  691.  
  692.     "unalias unalias     Undefine command alias",
  693.     "unalias Syntax:  unalias name ...",
  694.  
  695.     "unexport unexport    Remove environment variables from spawn export list",
  696.     "unexport Syntax:  unexport [ varname ... ]",
  697.  
  698.     "version version     Show libpvm version",
  699.     "version Syntax:  version",
  700.     0
  701. };
  702.  
  703.  
  704. help_cmd(ac, av)
  705.     int ac;
  706.     char **av;
  707. {
  708.     char **p;
  709.     char *topic;
  710.     int l;
  711.     struct cmdsw *csp;
  712.  
  713.     /* if not specified, topic = help */
  714.     if (ac > 1)
  715.         topic = av[1];
  716.     else
  717.         topic = "help";
  718.  
  719.     l = strlen(topic);
  720.  
  721.     /* search through messages for ones matching topic */
  722.     for (p = helptx; *p; p++) {
  723.         if (!strncmp(topic, *p, l) && ((*p)[l] == ' ' || (*p)[l] == '-'))
  724.             printf("%s\n", (*p) + l + 1);
  725.     }
  726.  
  727.     if (!strcmp(topic, "help")) {
  728.         printf("Commands are:\n");
  729.         for (csp = commands; csp->cmd; csp++) {
  730.             l = strlen(csp->cmd);
  731.             for (p = helptx; *p; p++)
  732.                 if (!strncmp(csp->cmd, *p, l) && (*p)[l] == ' ') {
  733.                     printf("  %s\n", (*p) + l + 1);
  734.                     break;
  735.                 }
  736.         }
  737.     }
  738.     return 0;
  739. }
  740.  
  741.  
  742. id_cmd(ac, av)
  743.     int ac;
  744.     char **av;
  745. {
  746.     ac = ac;
  747.     av = av;
  748.     printf("t%x\n", mytid);
  749.     return 0;
  750. }
  751.  
  752.  
  753. idump_cmd(ac, av)
  754.     int ac;
  755.     char **av;
  756. {
  757.     int how = 0;
  758.  
  759.     if (ac > 1)
  760.         how = atoi(av[1]);
  761.     i_dump(how);
  762.     return 0;
  763. }
  764.  
  765.  
  766. /*
  767. insert_cmd(ac, av)
  768.     int ac;
  769.     char **av;
  770. {
  771.     int cc;
  772.     int data;
  773.  
  774.     ac = ac;
  775.     data = axtoi(av[3]);
  776.     if ((cc = pvm_insert(av[1], axtoi(av[2]), data)) >= 0)
  777.         printf("%s, %d = 0x%08x\n", av[1], cc, data);
  778.     else
  779.         if (cc == PvmDupEntry)
  780.             printf("already exists\n");
  781.     return 0;
  782. }
  783. */
  784.  
  785.  
  786. jobs_cmd(ac, av)
  787.     int ac;
  788.     char **av;
  789. {
  790.     struct job *jp;
  791.     struct obuf *op;
  792.     int l = 0;
  793.     int ntask;
  794.     struct pvmtaskinfo *tip;
  795.  
  796.     if (ac > 1 && !strcmp(av[1], "-l")) {
  797.         l = 1;
  798.         print_task_hdr(0);
  799.         if (!hostlist)
  800.             pvm_config(&nhosts, &narchs, &hostlist);
  801.     }
  802.  
  803.     for (jp = joblist->j_link; jp != joblist; jp = jp->j_link) {
  804.         printf("%c%d:%s", (jp->j_flag & JOB_TRACE ? 'T' : ' '),
  805.                 jp->j_jid, (l ? "\n" : ""));
  806.         if (jp->j_obufs) {
  807.             for (op = jp->j_obufs->o_link; op != jp->j_obufs; op = op->o_link)
  808.                 if (l) {
  809.                     if (!pvm_tasks(op->o_tid, &ntask, &tip) && ntask == 1)
  810.                         print_task_rec(&tip[0], 0);
  811.                     else
  812.                         printf(" t%x", op->o_tid);
  813.                     printf("\n");
  814.                 } else
  815.                     printf(" t%x", op->o_tid);
  816.             if (!l)
  817.                 printf("\n");
  818.         }
  819.     }
  820.     return 0;
  821. }
  822.  
  823.  
  824. kill_cmd(ac, av)
  825.     int ac;
  826.     char **av;
  827. {
  828.     int i;
  829.     int tid, tid2;
  830.     char *p;
  831.     int host = 0;
  832.     int cflg = 0;
  833.     struct pvmtaskinfo *tip;
  834.     int ntask;
  835.  
  836.     if (ac > 1 && av[1][0] == '-') {
  837.         ac--;
  838.         for (p = *++av; *p; p++)
  839.             switch (*p) {
  840.  
  841.             case 'c':
  842.                 cflg = 1;
  843.                 break;
  844.  
  845.             case '-':
  846.                 break;
  847.  
  848.             default:
  849.                 printf("unknown flag -%c\n", *p);
  850.                 break;
  851.             }
  852.     }
  853.  
  854.     if (ac < 2) {
  855.         fputs("incorrect arg count\n", stdout);
  856.         return 1;
  857.     }
  858.  
  859.     if (cflg && pvm_tasks(host, &ntask, &tip) < 0)
  860.         return 1;
  861.  
  862.     while (ac > 1) {
  863.         ac--;
  864.         tid = tidtoi(*++av);
  865.  
  866.         if (cflg) {
  867.             for (i = 0; i < ntask; i++)
  868.                 if (tip[i].ti_ptid == tid) {
  869.                     tid2 = tip[i].ti_tid;
  870.                     if (tid2 != mytid)
  871.                         pvm_kill(tid2);
  872.                 }
  873.  
  874.         } else {
  875.             if (tid == mytid)
  876.                 printf("t%x: that's me.\n", tid);
  877.             else
  878.                 pvm_kill(tid);
  879.         }
  880.     }
  881.     return 0;
  882. }
  883.  
  884.  
  885. /*
  886. lookup_cmd(ac, av)
  887.     int ac;
  888.     char **av;
  889. {
  890.     int cc, data = 0;
  891.  
  892.     ac = ac;
  893.     if ((cc = pvm_lookup(av[1], axtoi(av[2]), &data)) >= 0)
  894.         printf("%s, %d = 0x%08x\n", av[1], cc, data);
  895.     else
  896.         if (cc == PvmNoEntry)
  897.             printf("no such entry\n");
  898.     return 0;
  899. }
  900. */
  901.  
  902.  
  903. mstat_cmd(ac, av)
  904.     int ac;
  905.     char **av;
  906. {
  907.     int i;
  908.     int cc;
  909.  
  910.     for (i = 1; i < ac; i++) {
  911.         cc = pvm_mstat(av[i]);
  912.         printf("%24s  %s\n", av[i], (cc < 0 ? PVMERRMSG(cc) : "ok"));
  913.     }
  914.     return 0;
  915. }
  916.  
  917.  
  918. pstat_cmd(ac, av)
  919.     int ac;
  920.     char **av;
  921. {
  922.     int i;
  923.     int tid;
  924.     int cc;
  925.  
  926.     for (i = 1; i < ac; i++) {
  927.         tid = tidtoi(av[i]);
  928.         cc = pvm_pstat(tid);
  929.         printf("t%8x  %s\n", tid, (cc < 0 ? PVMERRMSG(cc) : "run"));
  930.     }
  931.     return 0;
  932. }
  933.  
  934.  
  935. quit_cmd()
  936. {
  937.     printf("\n");
  938.     if (mytid > 0) {
  939.         pvm_exit();
  940.         printf("pvmd still running.\n");
  941.     }
  942.     exit(0);
  943.     return 0;  /* for stupid SGI compiler :-Q */
  944. }
  945.  
  946.  
  947. /*
  948. remove_cmd(ac, av)
  949.     int ac;
  950.     char **av;
  951. {
  952.     int cc;
  953.  
  954.     ac = ac;
  955.     if ((cc = pvm_delete(av[1], axtoi(av[2]))) > 0)
  956.         printf("deleted %s, %d\n", av[1], cc);
  957.     else
  958.         if (cc == PvmNoEntry)
  959.             printf("no such entry\n");
  960.     return 0;
  961. }
  962. */
  963.  
  964.  
  965. reset_cmd(ac, av)
  966.     int ac;
  967.     char **av;
  968. {
  969.     char *class = (char *) NULL;
  970.  
  971.     int killtasks = 1;
  972.     int index = -1;
  973.  
  974.     /* Check for Info (mbox) Reset */
  975.  
  976.     if ( ac > 1 ) {
  977.         if ( !strcmp( av[1], "info" ) ) {
  978.             killtasks = 0;
  979.             if ( ac > 2 ) {
  980.                 class = av[2];
  981.                 if ( ac > 3 )
  982.                     index = atoi( av[3] );
  983.             }
  984.         } else {
  985.             printf( "\"%s\" arg to reset not valid\n", av[1] );
  986.             return 1;
  987.         }
  988.     }
  989.  
  990.     /* Call the universal VM-spanker routine...  :-) */
  991.     pvmreset( mytid, killtasks, class, index );
  992.  
  993.     return 0;
  994. }
  995.  
  996.  
  997. setenv_cmd(ac, av)
  998.     int ac;
  999.     char **av;
  1000. {
  1001.     char **pp;
  1002.     char *p;
  1003.     char *sep;
  1004.     int n;
  1005.     int i;
  1006.  
  1007.     switch (ac) {
  1008.  
  1009.     case 1:
  1010.         for (pp = environ; *pp; pp++)
  1011.             printf("%s\n", *pp);
  1012.         break;
  1013.  
  1014.     case 2:
  1015.         if (p = getenv(av[1]))
  1016.             printf("%s\n", p);
  1017.         break;
  1018.  
  1019.     default:
  1020.         if (ac > 2) {
  1021.             n = 0;
  1022.             for (i = ac; i-- > 1; )
  1023.                 n += strlen(av[i]) + 1;
  1024.             p = TALLOC(n, char, "env");
  1025.             strcpy(p, av[1]);
  1026.             strcat(p, "=");
  1027.             sep = "";
  1028.             for (i = 2; i < ac; i++) {
  1029.                 strcat(p, sep);
  1030.                 strcat(p, av[i]);
  1031.                 sep = " ";
  1032.             }
  1033.             pvmputenv(p);
  1034.         }
  1035.         break;
  1036.     }
  1037.     return 0;
  1038. }
  1039.  
  1040.  
  1041. sig_cmd(ac, av)
  1042.     int ac;
  1043.     char **av;
  1044. {
  1045.     int i;
  1046.     int signum;
  1047.     int tid;
  1048.  
  1049.     signum = atoi(av[1]);
  1050.     for (i = 2; i < ac; i++) {
  1051.         tid = tidtoi(av[i]);
  1052.         pvm_sendsig(tid, signum);
  1053.     }
  1054.     return 0;
  1055. }
  1056.  
  1057.  
  1058. spawn_cmd(ac, av)
  1059.     int ac;
  1060.     char **av;
  1061. {
  1062.     int *tids = 0;
  1063.     char *where = 0;
  1064.     int flags = PvmNoSpawnParent;
  1065.     int count = 1;
  1066.     int i;
  1067.     int oflg = 0;
  1068.     int tflg = 0;
  1069.     int app;
  1070.     char *ofn = 0;
  1071.     char *tfn = 0;
  1072.     struct job *jp, *jp2;
  1073.     void status_msg();
  1074.     void event_dump_hdr();
  1075.     void output_dump_hdr();
  1076.  
  1077.     while (av[1][0] == '-') {
  1078.         if (ac < 3) {
  1079.             fputs("incorrect arg count\n", stdout);
  1080.             return 1;
  1081.         }
  1082.         if (av[1][1] == '~') {
  1083.             flags |= PvmHostCompl;
  1084.             av[1]++;
  1085.         }
  1086.         if (av[1][1] == '.' || islower(av[1][1])) {
  1087.             where = av[1] + 1;
  1088.             flags |= PvmTaskHost;
  1089.         }
  1090.         if (isupper(av[1][1])) {
  1091.             where = av[1] + 1;
  1092.             flags |= PvmTaskArch;
  1093.         }
  1094.         if (av[1][1] == '?')
  1095.             flags |= PvmTaskDebug;
  1096.         if (isdigit(av[1][1]))
  1097.             count = atoi(av[1] + 1);
  1098.         if (av[1][1] == '>') {
  1099.             oflg = 1;
  1100.             app = 0;
  1101.             ofn = av[1] + 2;
  1102.             if (av[1][2] == '>') {
  1103.                 app = 1;
  1104.                 ofn++;
  1105.             }
  1106.             if (!*ofn)
  1107.                 ofn = 0;
  1108. /*
  1109.             printf("%s to %s\n", (app ? "Append" : "Write"),
  1110.                     (ofn ? ofn : "(console)"));
  1111. */
  1112.         }
  1113.         if (av[1][1] == '@') {
  1114.             tflg = 1;
  1115.             tfn = av[1] + 2;
  1116.             if (!*tfn)
  1117.                 tfn = "";
  1118.         }
  1119.         av++;
  1120.         ac--;
  1121.     }
  1122.     if (tflg) {
  1123.         jp2 = job_new(nextjob);
  1124.         jp2->j_flag |= JOB_TRACE;
  1125.         jp2->j_trcid = trc_get_tracer_id();
  1126.         jp2->j_trcid->status_msg = status_msg;
  1127.         if (tfn && !strcmp(tfn,""))
  1128.             jp2->j_trcid->event_dump_hdr = event_dump_hdr;
  1129.         if (oflg && !ofn) ofn = "";
  1130.         if (ofn)
  1131.             jp2->j_trcid->output_dump_hdr = output_dump_hdr;
  1132.         jp2->j_trcid->event_ctx = pvm_getcontext();
  1133.         jp2->j_trcid->event_tag = nextjob;
  1134.         jp2->j_trcid->output_ctx = pvm_getcontext();
  1135.         jp2->j_trcid->output_tag = nextjob + 1;
  1136.         trc_set_tracing_codes( jp2->j_trcid );
  1137.         printf("[%d]\n", nextjob);
  1138.         nextjob += 2;
  1139.         trc_set_trace_file( jp2->j_trcid, tfn );
  1140.         if (!trc_reset_trace_file( jp2->j_trcid )) {
  1141.             job_free(jp2);
  1142.             return 1;
  1143.         }
  1144.         trc_save_host_status_events( jp2->j_trcid );
  1145.         if (ofn) {
  1146.             trc_set_output_file( jp2->j_trcid, ofn );
  1147.             if (!trc_open_output_file( jp2->j_trcid )) {
  1148.                 job_free(jp2);
  1149.                 return 1;
  1150.             }
  1151.         }
  1152.         oflg = 0;
  1153.     }
  1154.     else {
  1155.         pvm_setopt(PvmTraceTid, 0);
  1156.  
  1157.         if (oflg) {
  1158.             pvm_setopt(PvmOutputTid, mytid);
  1159.             pvm_setopt(PvmOutputContext, pvm_getcontext());
  1160.             pvm_setopt(PvmOutputCode, nextjob);
  1161.             jp = job_new(nextjob);
  1162.             printf("[%d]\n", nextjob++);
  1163.             if (ofn) {
  1164.                 jp->j_ff = fopen(ofn, (app ? "a" : "w"));
  1165.                 if (!jp->j_ff) {
  1166.                     perror(ofn);
  1167.                     job_free(jp);
  1168.                     return 1;
  1169.                 }
  1170.             }
  1171.         } else
  1172.             pvm_setopt(PvmOutputTid, 0);
  1173.     }
  1174.  
  1175.     tids = TALLOC(count > 1 ? count : 1, int, "int");
  1176.     if ((i = pvm_spawn(av[1], &av[2], flags, where, count, tids)) >= 0) {
  1177.         if (oflg & !i)
  1178.             job_free(jp);
  1179.         if (tflg & !i)
  1180.             job_free(jp2);
  1181.         printf("%d successful\n", i);
  1182.         for (i = 0; i < count; i++)
  1183.             if (tids[i] < 0)
  1184.                 printf("%s\n", PVMERRMSG(tids[i]));
  1185.             else
  1186.                 printf("t%x\n", tids[i]);
  1187.     }
  1188.     MY_FREE(tids);
  1189.     return 0;
  1190. }
  1191.  
  1192.  
  1193. static char *tflgs[] = {
  1194.     0, "f", "c", "a", "o", "s", 0, 0,
  1195.     "R", "H", "T"
  1196. };
  1197.  
  1198. char *
  1199. task_flags(f)
  1200.     int f;
  1201. {
  1202.     static char buf[64];
  1203.     int bit, i;
  1204.  
  1205.     sprintf(buf, "%x/", f);
  1206.     i = sizeof(tflgs)/sizeof(tflgs[0]) - 1;
  1207.     bit = 1 << i;
  1208.     while (i >= 0) {
  1209.         if ((f & bit) && tflgs[i]) {
  1210.             strcat(buf, tflgs[i]);
  1211.             strcat(buf, ",");
  1212.         }
  1213.         bit /= 2;
  1214.         i--;
  1215.     }
  1216.     buf[strlen(buf) - 1] = 0;
  1217.     return buf;
  1218. }
  1219.  
  1220.  
  1221. print_task_hdr(lflg)
  1222.     int lflg;
  1223. {
  1224.     if (lflg)
  1225.         fputs("                    HOST      TID     PTID    PID   FLAG 0x COMMAND\n",
  1226.             stdout);
  1227.     else
  1228.         fputs("                    HOST      TID   FLAG 0x COMMAND\n",
  1229.             stdout);
  1230.     return 0;
  1231. }
  1232.  
  1233.  
  1234. print_task_rec(tip, lflg)
  1235.     struct pvmtaskinfo *tip;
  1236.     int lflg;
  1237. {
  1238.     struct pvmhostinfo *hip = 0;
  1239.  
  1240.     if (hostlist) {
  1241.         for (hip = hostlist + nhosts - 1; hip >= hostlist; hip--)
  1242.             if (hip->hi_tid == tip->ti_host)
  1243.                 break;
  1244.         if (hip < hostlist)
  1245.             hip = 0;
  1246.     }
  1247.     if (hip)
  1248.         printf("%24s", hip->hi_name);
  1249.     else
  1250.         printf("%24x", tip->ti_host);
  1251.     if (tip->ti_tid == mytid)
  1252.         printf("   (cons)");
  1253.     else
  1254.         printf(" %8x", tip->ti_tid);
  1255.     if (lflg) {
  1256.         if (tip->ti_ptid == mytid)
  1257.             printf("   (cons)");
  1258.         else
  1259.             if (tip->ti_ptid)
  1260.                 printf(" %8x", tip->ti_ptid);
  1261.             else
  1262.                 printf("        -");
  1263.         printf(" %6d", tip->ti_pid);
  1264.     }
  1265.     printf(" %9s", task_flags(tip->ti_flag));
  1266.     printf(" %-12s", tip->ti_a_out[0] ? tip->ti_a_out : "-");
  1267.     return 0;
  1268. }
  1269.  
  1270.  
  1271. tasks_cmd(ac, av)
  1272.     int ac;
  1273.     char **av;
  1274. {
  1275.     struct pvmtaskinfo *tip;
  1276.     int ntask;
  1277.     int i;
  1278.     struct pvmhostinfo *hip = 0;
  1279.     int xflg = 0;
  1280.     char *p;
  1281.     int host = pvm_tidtohost(mytid);
  1282.     int lflg = 0;
  1283.  
  1284.     if (!hostlist)
  1285.         pvm_config(&nhosts, &narchs, &hostlist);
  1286.  
  1287.     if (ac > 1) {
  1288.         for (p = av[1]; *p; p++)
  1289.             switch (*p) {
  1290.  
  1291.             case 'n':
  1292.                 p++;
  1293.                 if (!strcmp(p, "."))
  1294.                     pvm_tidtohost(mytid);
  1295.                 else {
  1296.                     for (hip = hostlist + nhosts; --hip >= hostlist; )
  1297.                         if (!(strcmp(p, hip->hi_name))) {
  1298.                             host = hip->hi_tid;
  1299.                             break;
  1300.                         }
  1301.                     if (hip < hostlist)
  1302.                         printf("unknown host %s\n", p);
  1303.                 }
  1304.                 while (*p)
  1305.                     p++;
  1306.                 p--;
  1307.                 break;
  1308.  
  1309.             case 'h':
  1310.                 host = tidtoi(++p);
  1311.                 while (*p)
  1312.                     p++;
  1313.                 p--;
  1314.                 break;
  1315.  
  1316.             case 'a':
  1317.                 host = 0;
  1318.                 break;
  1319.  
  1320.             case 'l':
  1321.                 lflg = 1;
  1322.                 break;
  1323.  
  1324.             case 'x':
  1325.                 xflg = 1;
  1326.                 break;
  1327.  
  1328.             case '-':
  1329.                 break;
  1330.  
  1331.             default:
  1332.                 printf("unknown flag -%c\n", *p);
  1333.                 break;
  1334.             }
  1335.     }
  1336.  
  1337.     if (!pvm_tasks(host, &ntask, &tip)) {
  1338.         print_task_hdr(lflg);
  1339.         for (i = 0; i < ntask; i++) {
  1340.             if (!xflg && (tip[i].ti_tid == mytid || tip[i].ti_tid == 0))
  1341.                 continue;
  1342.             print_task_rec(&tip[i], lflg);
  1343.             printf("\n");
  1344.         }
  1345.     }
  1346.     return 0;
  1347. }
  1348.  
  1349.  
  1350. tickle_cmd(ac, av)
  1351.     int ac;
  1352.     char **av;
  1353. {
  1354.     int nar;
  1355.     int arg[10];
  1356.     int i;
  1357.  
  1358.     ac--;
  1359.     av++;
  1360.     for (nar = 0; nar < ac; nar++)
  1361.         arg[nar] = axtoi(av[nar]);
  1362.  
  1363.     if (!pvm_tickle(nar, arg, &nar, arg)) {
  1364.         printf("(");
  1365.         for (i = 0; i < nar; i++)
  1366.             printf(" %d", arg[i]);
  1367.         printf(" )\n");
  1368.     }
  1369.     return 0;
  1370. }
  1371.  
  1372.  
  1373. printtm(who)
  1374.     int who;
  1375. {
  1376.     Pvmtmask tm;
  1377.  
  1378.     pvm_gettmask(who, tm);
  1379.  
  1380.     trc_print_tmask(tm);
  1381.  
  1382.     return 0;
  1383. }
  1384.  
  1385.  
  1386. trace_cmd(ac, av)
  1387.     int ac;
  1388.     char **av;
  1389. {
  1390.     static int topt = PvmTraceFull;
  1391.     static int tbuf = 0;
  1392.     int i;
  1393.     int onoff = 1;
  1394.     int e;
  1395.     int l;
  1396.     char buf[64];
  1397.     char *optstr;
  1398.     Pvmtmask tm;
  1399.     int settm;
  1400.  
  1401.     if (ac == 1) {
  1402.         printtm(PvmTaskChild);
  1403.         return 0;
  1404.     }
  1405.  
  1406.     pvm_gettmask(PvmTaskChild, tm);
  1407.  
  1408.     settm = 0;
  1409.  
  1410.     for (i = 1; i < ac; i++) {
  1411.         if (!strcmp(av[i], "+")) {
  1412.             onoff = 1;
  1413.         } else if (!strcmp(av[i], "-")) {
  1414.             onoff = 0;
  1415.         } else if (!strcmp(av[i], "*")) {
  1416.             for (e = TEV_FIRST; e <= TEV_MAX; e++) {
  1417.                 if (onoff)
  1418.                     TEV_MASK_SET(tm, e);
  1419.                 else
  1420.                     TEV_MASK_UNSET(tm, e);
  1421.             }
  1422.             settm++;
  1423.         } else if (!strcmp(av[i], "buf")) {
  1424.             if ( i + 1 < ac ) {
  1425.                 tbuf = atoi(av[++i]);
  1426.                 pvm_setopt( PvmTraceBuffer, tbuf );
  1427.             } else {
  1428.                 printf("\nTrace Buffering set to %d bytes\n\n", tbuf);
  1429.             }
  1430.         } else if (!strcmp(av[i], "opt")) {
  1431.             if ( i + 1 < ac ) {
  1432.                 i++;
  1433.                 if ( !strcmp( av[i], "full" ) )
  1434.                     topt = PvmTraceFull;
  1435.                 else if ( !strcmp( av[i], "time" ) )
  1436.                     topt = PvmTraceTime;
  1437.                 else if ( !strcmp( av[i], "count" ) )
  1438.                     topt = PvmTraceCount;
  1439.                 else {
  1440.                     printf( "\nError:  Unknown Trace Option \"%s\"\n\n",
  1441.                         av[i] );
  1442.                 }
  1443.                 pvm_setopt( PvmTraceOptions, topt );
  1444.             } else {
  1445.                 switch ( topt )
  1446.                 {
  1447.                     case PvmTraceFull:        optstr = "full";    break;
  1448.                     case PvmTraceTime:        optstr = "time";    break;
  1449.                     case PvmTraceCount:        optstr = "count";    break;
  1450.                     default: {
  1451.                         sprintf( buf, "<Unknown=%d>", topt );
  1452.                         optstr = buf;
  1453.                     }
  1454.                 }
  1455.                 printf("\nTrace Options set to \"%s\"\n\n", optstr );
  1456.             }
  1457.         } else if (!strcmp(av[i], "xpvm")) {
  1458.             TEV_MASK_INIT( tm );
  1459.             TEV_MASK_SET( tm, TEV_BARRIER );
  1460.             TEV_MASK_SET( tm, TEV_BCAST );
  1461.             TEV_MASK_SET( tm, TEV_JOINGROUP );
  1462.             TEV_MASK_SET( tm, TEV_LVGROUP );
  1463.             TEV_MASK_SET( tm, TEV_MYTID );
  1464.             TEV_MASK_SET( tm, TEV_PARENT );
  1465.             TEV_MASK_SET( tm, TEV_SPAWN );
  1466.             TEV_MASK_SET( tm, TEV_SENDSIG );
  1467.             TEV_MASK_SET( tm, TEV_KILL );
  1468.             TEV_MASK_SET( tm, TEV_EXIT );
  1469.             TEV_MASK_SET( tm, TEV_MCAST );
  1470.             TEV_MASK_SET( tm, TEV_SEND );
  1471.             TEV_MASK_SET( tm, TEV_RECV );
  1472.             TEV_MASK_SET( tm, TEV_RECVF );
  1473.             TEV_MASK_SET( tm, TEV_NRECV );
  1474.             TEV_MASK_SET( tm, TEV_PSEND );
  1475.             TEV_MASK_SET( tm, TEV_PRECV );
  1476.             TEV_MASK_SET( tm, TEV_TRECV );
  1477.             TEV_MASK_SET( tm, TEV_PROBE );
  1478.             settm++;
  1479.         } else {
  1480.             if (!strncmp(av[i], "pvm_", 4))
  1481.                 strcpy(buf, av[i] + 4);
  1482.             else
  1483.                 strcpy(buf, av[i]);
  1484.             for (e = TEV_FIRST; e <= TEV_MAX; e++)
  1485.                 if (!strcmp(pvmtevinfo[e].name, buf)
  1486.                 || !strcmp(pvmtevinfo[e].name, av[i]))
  1487.                     break;
  1488.             if ( e <= TEV_MAX ) {
  1489.                 if (onoff)
  1490.                     TEV_MASK_SET(tm, e);
  1491.                 else
  1492.                     TEV_MASK_UNSET(tm, e);
  1493.                 settm++;
  1494.             }
  1495.             else
  1496.                 printf("no such event \"%s\"\n", av[i]);
  1497.         }
  1498.     }
  1499.  
  1500.     if ( settm )
  1501.         pvm_settmask(PvmTaskChild, tm);
  1502.  
  1503.     return 0;
  1504. }
  1505.  
  1506.  
  1507. unalias_cmd(ac, av)
  1508.     int ac;
  1509.     char **av;
  1510. {
  1511.     struct alias *ap;
  1512.     int i;
  1513.  
  1514.     for (i = 1; i < ac; i++)
  1515.         if (ap = findalias(av[i]))
  1516.             freealias(ap);
  1517.     return 0;
  1518. }
  1519.  
  1520.  
  1521. version_cmd(ac, av)
  1522.     int ac;
  1523.     char **av;
  1524. {
  1525.     ac = ac;
  1526.     av = av;
  1527.     printf("%s\n", pvm_version());
  1528.     return 0;
  1529. }
  1530.  
  1531.  
  1532. names_cmd(ac, av)
  1533.     int ac;
  1534.     char **av;
  1535. {
  1536.     struct pvmmboxinfo *classes;
  1537.     int nclasses;
  1538.     int i, j;
  1539.     int cc;
  1540.  
  1541.     pvm_getmboxinfo((ac > 1 ? av[1] : "*"), &nclasses, &classes);
  1542.     for ( i=0 ; i < nclasses ; i++ )
  1543.     {
  1544.         printf("<%s>:\n", classes[i].mi_name);
  1545.         for ( j=0 ; j < classes[i].mi_nentries ; j++ )
  1546.             printf("\tindex=%d owner=0x%x/%d flags=0x%x\n",
  1547.                 classes[i].mi_indices[j],
  1548.                 classes[i].mi_owners[j], classes[i].mi_owners[j],
  1549.                 classes[i].mi_flags[j] );
  1550.         printf("\n");
  1551.     }
  1552.     return 0;
  1553. }
  1554.  
  1555.  
  1556. put_cmd(ac, av)
  1557.     int ac;
  1558.     char **av;
  1559. {
  1560.     int cc;
  1561.  
  1562.     pvm_packf("%+ %d", PvmDataDefault, 0);
  1563.     cc = pvm_putinfo(av[1], pvm_getsbuf(), (int)atoi(av[2]));
  1564.     if (cc < 0)
  1565.         printf("%s\n", pvm_errlist[-cc]);
  1566.     return 0;
  1567. }
  1568.  
  1569.  
  1570. export_cmd(ac, av)
  1571.     int ac;
  1572.     char **av;
  1573. {
  1574.     int i;
  1575.     char *p;
  1576.  
  1577.     if (ac == 1) {
  1578.         p = getenv("PVM_EXPORT");
  1579.         printf("PVM_EXPORT=%s\n", p ? p : "");
  1580.  
  1581.     } else {
  1582.         for (i = 1; i < ac; i++)
  1583.             pvm_export(av[i]);
  1584.     }
  1585.     return 0;
  1586. }
  1587.  
  1588.  
  1589. unexport_cmd(ac, av)
  1590.     int ac;
  1591.     char **av;
  1592. {
  1593.     int i;
  1594.  
  1595.     for (i = 1; i < ac; i++)
  1596.         pvm_unexport(av[i]);
  1597.     return 0;
  1598. }
  1599.  
  1600.  
  1601.